import type { FormRules } from "element-plus";

// 任意对象
export interface AnyObj {
    [propName: string]: any;
}

export type FormFieldValue = any; // 表单字段数据类型

export type FormItemComponentType = 'input' | 'inputNumber' | 'select' | 'selectV2' | 'datePicker' | 'dateTimePicker' | 'checkbox' | 'radio' | 'switch' | 'treeSelect' | 'upload' | 'timePeriod' | 'datePeriod' | 'colorPicker' | 'address' | 'threeLevelPicker' | 'custom';

export type InputType = 'text' | 'number' | 'password' | 'tel' | 'textarea';

// export type DateType = 'year' | 'month' | 'date' | 'dates' | 'datetime' | 'week' | 'datetimerange' | 'daterange' | 'monthrange';
export type DateType = 	'year' | 'month' | 'date' | 'dates' | 'datetime' | 'week' | 'datetimerange' | 'daterange' | 'monthrange';

// 日期快捷键
// 单选，Today为今天,Yesterday为昨天，A week ago为上周
// 范围选择，Last week为上周内，Last month为上月内，Last 3 months为最近三个月
export type DateShortcutsType = 'Today' | 'Yesterday' | 'A week ago' | 'Last week' | 'Last month' | 'Half month' | 'Last 3 months';

export type DateFormatType = "YYYY-MM-DD" | "YYYY-MM-DD HH:mm" | "YYYY-MM-DD HH:mm:ss";

// 文件上传配置
export interface UploadConfigType {
    multiple?: boolean; // 是否支持多选文件
    name?: string; // 上传的文件字段名 
    withCredentials?: boolean; // 支持发送 cookie 凭证信息，默认true
    showFileList?: boolean; // 是否显示已上传文件列表
    drag?: boolean; // 是否启用拖拽上传
    accept?: string; // 接受上传的文件类型（thumbnail-mode 模式下此参数无效），默认为'image/*'，支持传doc(文档类型)
    listType?: 'text' | 'picture' | 'picture-card';
    limit?: number;
    onChange?: Function;
}

export interface DateConfigType {
    type?: DateType; // 显示类型
    disabledDate?: Function;
    shortcuts?: DateShortcutsType[];
    clearable?: boolean; // 是否显示清除按钮 默认 true
    startPlaceholder?: string; // 范围选择时开始的占位内容
    endPlaceholder?: string; // 范围选择时结束的占位内容
    format?: string | 'YYYY-MM-DD';
    rangeSeparator?: string | ',';
    valueFormat?: DateFormatType;
    defaultValue?: Date | [Date, Date];
    rangeLimitDay?: number; // 可以选择的区间天数，不传则不限制
    rangeKey?: boolean | string[];
}

export interface TimeConfigType {
    readonly?: boolean;
    disabled?: boolean;
    editable?: boolean;
    clearable?: boolean;
    startPlaceholder?: string; // 范围选择时开始的占位内容
    endPlaceholder?: string; // 范围选择时结束的占位内容
    isRange?: boolean; // 是否时间范围选择
    arrowControl?: boolean; // 是否使用箭头进行时间选择
}

export interface FormComponentApiType { // select、treeSelect、checkbox、radio列表，对应的获取列表数据接口配置
    url: string | MandatoryStringFunction; // 对应request函数的url字段
    method?: 'post' | 'get'; // 对应request函数的method字段
    query?: AnyObj | Function; // 对应request函数的query字段
    data?: AnyObj | Function; // 对应request函数的data字段
    contentTypeIsForm?: boolean; // 对应request函数的contentTypeIsForm字段
    dataTransfer?: Function; // 获取时的数据转换函数，第一个参数为当前表单数据
}

export interface SelectPropsType {
    label?: string | string[];
    key?: string | string[];
    disabled?: string | 'disabled';
    placeholder?: string;
    labelRangeSeparator?: string;
    keyRangeSeparator?: string;
}

// 依赖管理
export interface DependenciesFormComponent {
    key: string; // 表单项对应的key
    requestKey?: string; // 列表请求时的key
    required?: boolean; // 列表请求是否必须依赖，是则不为空就请求获取数据，否则只该要依赖有变化都请求数据，默认否
    dataPlace?: 'body' | 'query'; // 放到请求的url路径还是请求的body里面，默认根据api.method来判断
    notGanged?: boolean; // 是否不联动，有时仅仅是请求url变化
};

// 输入框配置
export interface InputConfig {
    maxlength?: string | number;
    minlength?: number;
    prepend?: {
        type?: 'select';
        selectPlaceholder?: string;
    };
    paste?: {
        toKey?: string;
    };
    autosize?: {
        minRows?: number;
        maxRows?: number;
    };
    max?: number;
    min?: number;
};

// 通用表单组件项类型
export interface FormComponentType {
    type?: FormItemComponentType; // 类型
    inputType?: InputType;
    inputConfig?: InputConfig;
    isAtWindow?: boolean; // 是否在弹窗里面
    api?: FormComponentApiType;
    topAllOption?: boolean | AnyObj;// 列表顶部增加一项'全部'
    list?: any[]; // 选择项，多选、单选、选择框等数据
    listNonexecutionApi?: boolean; // 是否在onMounted、onActivated时不执行接口获取列表
    autoSelectKey?: string; // 为select类型时，是否默认选择第一项，是则根据key设置当前选择项
    selectProps?: SelectPropsType; // select、checkbox、radio列表 属性对应的key
    dataRangeSeparator?: string; // 数据分隔符，如checkbox，接口返回的值为"11,22"，则设置为","
    class?: string[];
    placeholder?: string;
    clearable?: boolean;
    disabled?: boolean;
    size?: 'large' | 'default' | 'small';
    switch?: {
        activeText?: string; // switch 打开时的文字描述
        inactiveText?: string; // switch 的状态为 off 时的文字描述
        inlinePrompt?: boolean; // 
        activeValue?: boolean | string | number;
        inactiveValue?: boolean | string | number;
    };
    multiple?: boolean; // 是否多选，checkbox为true
    multipleLimit?: number; // multiple 属性设置为 true 时，代表多选场景下用户最多可以选择的项目数， 为 0 则不限制
    hideSelectAll?: boolean; // 选择框多选时，是否不显示全选按钮
    validateEvent?: boolean;
    collapseTags?: boolean; // 多选时是否将选中值按文字的形式展示
    collapseTagsTooltip?: boolean; // 当鼠标悬停于折叠标签的文本时，是否显示所有选中的标签。 要使用此属性，collapse-tags属性必须设定为 true
    dependencies?: DependenciesFormComponent | DependenciesFormComponent[]; // 当前列表依赖某个表单项
    onChange?: FormComponentChangeFunction; // 数据更新时执行的事件，callback({formData, list, value}) => {}
    onAcquiredList?: FormComponentAcquiredListFunction; // 获取列表后，主动触发的事件
    date?: DateConfigType;
    time?: TimeConfigType;
    style?: DomStyle;
    radio?: {
        buttonStyle?: boolean; // 是否以按钮形式展示
    };
    treeSelect?: {
        checkStrictly?: boolean; // 是否任何节点都可以被选择 默认false
        emptyText?: string; // 内容为空的时候展示的文本
        nodeKey?: string; // 每个树节点用来作为唯一标识的属性，整棵树应该是唯一的
        defaultExpandAll?: boolean; // default-expand-all 是否默认展开所有节点 默认false
        expandOnClickNode?: boolean; // expand-on-click-node 是否在点击节点的时候展开或者收缩节点， 默认值为 true，如果为 false，则只有点箭头图标的时候才会展开或者收缩节点。
        checkOnClickNode?: boolean;
        accordion?: boolean; // 是否每次只打开一个同级树节点展开 默认false
        props?: {
            label?: string;
            children?: string;
            disabled?: string;
            isLeaf?: string; // 指定节点是否为叶子节点，仅在指定了 lazy 属性的情况下生效
            class?: string;
        };
        parentSelect?: boolean; // 父节点是否可以选择
    };
    upload?: UploadConfigType;
}

// 定义返回string类型的函数
export interface MandatoryBooleanFunction {
    (data?: any): boolean;
}

// FormComponent组件数据更新时执行的函数类型
export interface FormComponentChangeFunction {
    ({ formData, list, value } : { formData: AnyObj, list?: AnyObj[], value: any }): any;
}

export interface FormComponentAcquiredListFunction {
    (list: AnyObj[]): void;
}

// 通用表单项类型
export interface FormItemType extends FormComponentType {
    required?: boolean;
    value?: FormFieldValue; // 默认值
    key: string; // 字段key
    label?: string; // 标签文本
    labelWidth?: string | number; // 标签宽度，例如 '50px'。 可以使用 auto。
    desc?: string;
    hidden?: boolean | MandatoryBooleanFunction;
    formItemStyle?: AnyObj;
    keys?: {
        inputkey: string;
        selectKey: string;
    } | string[];
}

export type FormButtonsType = 'get' | 'submit' | 'clear' | 'custom' | 'cancel';

export type FormButtonsTypeConfig = {
    type: FormButtonsType; // get为查询按钮，submit为保存按钮，clear为清空按钮，custom为自定义
    text?: string; // 按钮文字，custom必填，空则默认根据type显示文字，get为查询，submit为保存，clear为清空，
    typeStyle?: 'primary'| 'success'| 'warning'| 'danger'| 'info'| 'text';
    callback?: Function; // 点击触发的函数
}

// 定义返回string类型的函数
export interface MandatoryStringFunction {
    (data?: any): Promise<string> | string;
};

// 定义返回任意对象类型的函数
export interface MandatoryAnyObjFunction {
    (data?: any): Promise<AnyObj> | AnyObj;
}

// 定义返回任意类型的函数
export interface MandatoryAnyFunction {
    (data?: any): Promise<any> | any;
}

export interface SubmitApiDataTransferFunction {
    ({requestData, formData, routeParams, formItemListData} : {requestData: AnyObj; formData: AnyObj; routeParams: AnyObj; formItemListData: AnyObj;}): AnyObj | Promise<AnyObj>;
}

export interface RequestApiType {
    url: string | MandatoryStringFunction; // 编辑/新增时，请求的url，支持函数以promise返回url
    method?: 'post' | 'get', // 请求方式
    query?: AnyObj | MandatoryAnyFunction | string | number; // 请求url参数，get的时候传，post时可以加传，支持promise异步
    data?: AnyObj | MandatoryAnyFunction | string | number; // 请求body参数，post的时候传，支持promise异步
    errorToast?: boolean; // 请求失败是否提示，默认为true
    contentTypeIsForm?: boolean; // post时传，true"content-type"为"application/x-www-form-urlencoded"，false为"application/json"
    showLoading?: { // 是否显示loading，对应的是ElementUI的ElLoading.service参数，默认为{}
        text?: string;
        lock?: boolean;
        background?: string;
    },
    dataTransfer?: MandatoryAnyObjFunction; // 提交时的数据转换函数，第一个参数为当前表单数据，以return时的数据为准
}

export interface SubmitApiType extends RequestApiType {
    submitText?: string;
    hideButton?: boolean;
}

// 通用表单，提交成功后的执行的函数
export interface FormSuccessCallbackFunction {
    ({data, isDetail, requestData, formData, resetFields} : { data: AnyObj, isDetail: boolean, requestData: AnyObj, formData: AnyObj,  resetFields: Function}): Promise<any> | any;
}

// // 定义返回任意对象类型的函数
export interface DetailApiMandatoryAnyObjFunction {
    (data: any, formData: AnyObj): Promise<AnyObj> | AnyObj;
}

export interface DetailApi {
    url: string | MandatoryStringFunction; // 编辑/新增时，请求的url，支持函数以promise返回url
    method?: 'post' | 'get', // 请求方式
    query?: AnyObj | MandatoryAnyFunction | string | number; // 请求url参数，get的时候传，post时可以加传，支持promise异步
    data?: AnyObj | MandatoryAnyFunction | string | number; // 请求body参数，post的时候传，支持promise异步
    errorToast?: boolean; // 请求失败是否提示，默认为true
    contentTypeIsForm?: boolean; // post时传，true"content-type"为"application/x-www-form-urlencoded"，false为"application/json"
    showLoading?: { // 是否显示loading，对应的是ElementUI的ElLoading.service参数，默认为{}
        text?: string;
        lock?: boolean;
        background?: string;
    },
    dataTransfer?: DetailApiMandatoryAnyObjFunction;
}

interface FormValidate {
    ({formData, formItemListData} : { formData: AnyObj; formItemListData: AnyObj }): boolean | Promise<boolean>;
}

interface PasteFn {
    ({file, event, url} : {file?: File, event: ClipboardEvent, url: string}): void;
}

// 通用表单传参类型
export interface FormType {
    inline?: boolean; // 是否为行内表单
    labelPosition?: 'left' | 'right' | 'top'; // 表单域标签的位置， 当设置为 left 或 right 时，则也需要设置 label-width 属性
    formItemList?: FormItemType[], // 表单列表
    rules?: FormRules; // 表单校验规则，自定义校验函数可以在首个参数rule的source属性访问formData
    labelWidth?: string | number; // 标签的长度，例如 '50px'。 作为 Form 直接子元素的 form-item 会继承该值。 可以使用 auto。
    disabled?: boolean; // 是否禁用
    isView?: boolean; // 是否为查看表单，是则显示列表页面
    buttons?: FormButtonsTypeConfig[]; // 功能按钮，如保存、查询
    isAtWindow?: boolean; // 是否显示在弹窗里面
    submitApi?: SubmitApiType; // 提交时请求的接口
    cancelCallback?: boolean | Function; // 点击取消/返回按钮时，是否执行页面返回或执行回调函数
    successBack?: boolean | Function; // 提交成功是否返回上一级页面
    submit?: Function; // 保存提交函数 submit(formData)，不传则根据submitApi执行提交
    validate?: FormValidate;
    disabledGetButton?: boolean | MandatoryBooleanFunction;
    showGetButton?: boolean; // 是否显示查询按钮
    showClearBtn?: boolean; // 是否显示清空按钮
    detailApi?: DetailApi; // 获取详情接口时调用
    formDataInit?: Function; // 表单数据初始化函数，要求返回一个对象
    isPageTable?: boolean;
    successCallback?: FormSuccessCallbackFunction; // 新增、编辑成功的回调函数，没有则自动返回上一级页面
    paste?: {
        callback?: PasteFn;
        uploadImage?: boolean;
    };
    validationBeforeSubmit?: { // 执行提交之前，是否显示确认弹窗
        title?: string; // 标题，默认为"提示""
        content?: string; // 内容，默认为"是否提交？""
        confirmButtonText?: string; // 确定按钮文案，默认为"确认""
        cancelButtonText?: string; // 取消按钮文案，默认为"取消"
    }
}

export interface DataGetterFunction {
    (data: any, index: number): string | number;
}

// 表格列数据
export interface TableColumnType {
    type?: 'selection' | 'index' | 'expand'; // 对应列的类型。 如果设置了selection则显示多选框； 如果设置了 index 则显示该行的索引（从 1 开始计算）； 如果设置了 expand 则显示为一个可展开的按钮
    index?: number | Function; // 如果设置了 type=index，可以通过传递 index 属性来自定义索引
    label?: string; // 显示的标题
    prop?: string; // 字段名称 对应列内容的字段名， 也可以使用 property属性
    width?: string | number; // 对应列的宽度
    minWidth?: string | number; // 对应列的最小宽度， 对应列的最小宽度， 与 width 的区别是 width 是固定的，min-width 会把剩余宽度按比例分配给设置了 min-width 的列
    fixed?: true | 'left' | 'right'; // 列是否固定在左侧或者右侧。 true 表示固定在左侧
    renderHeader?: Function; // 列标题 Label 区域渲染使用的 function({ column, $index })
    sortable?: boolean | 'custom'; // 对应列是否可以排序， 如果设置为 'custom'，则代表用户希望远程排序，需要监听 Table 的 sort-change 事件
    sortMethod?: Function; // 指定数据按照哪个属性进行排序，仅当sortable设置为true的时候有效。 应该如同 Array.sort 那样返回一个 Number function(a, b)
    resizable?: boolean; // 对应列是否可以通过拖动改变宽度（需要在 el-table 上设置 border 属性为真）
    formatter?: Function; // 用来格式化内容	 function(row, column, cellValue, index)
    align?: 'left' | 'center' | 'right'; // 对齐方式
    headerAlign?: 'left' | 'center' | 'right'; // 表头对齐方式， 若不设置该项，则使用表格的对齐方式
    className?: string; // 列的 className
    labelClassName?: string; // 当前列标题的自定义类名
    selectable?: Function; // 仅对 type=selection 的列有效，类型为 Function，Function 的返回值用来决定这一行的 CheckBox 是否可以勾选
    showOverflowTooltip?: boolean; // 默认为true
    dataGetter?: DataGetterFunction;
}

export interface BeforeGetListFunction {
    ({ formData } : { formData: AnyObj }): boolean;
}

export type DomStyle = {
    [propName: string]: string | number
}

export interface StringFunction {
    (data?: any): string | Promise<string>;
}

// 表格配置列表
export interface TableConfigType {
    class?: string | object | string[] | number[]; // 表格的类名
    fit?: boolean; // 列的宽度是否自撑开
    rowClassName?: string | Function; // 行的 className 的回调方法，也可以使用字符串为所有行设置一个固定的 className。
    showSummary?: boolean; // 是否在表尾显示合计行
    sumText?: string; // 显示摘要行第一列的文本
    summaryMethod?: Function; // 自定义的合计计算方法
    spanMethod?: Function; // 合并行或列的计算方法
    selectOnIndeterminate?: boolean; // 在多选表格中，当仅有部分行被选中时，点击表头的多选框时的行为。 若为 true，则选中所有行；若为 false，则取消选择所有行
    indent?: number; // 展示树形数据时，树节点的缩进
    scrollbarAlwaysOn?: boolean; // 总是显示滚动条
    border?: boolean; // 是否带有纵向边框
    rowKey?: string | Function; // 行数据的 Key，用来优化 Table 的渲染； 在使用reserve-selection功能与显示树形数据时，该属性是必填的。 类型为 String 时，支持多层访问：user.info.id，但不支持 user.info[0].id，此种情况请使用 Function。function(row) / string
    tableColumns: TableColumnType[]; // 表格列设置
    getDataOnShow?: boolean; // 页面显示时是否自动获取表格数据，默认为false
    beforeGetList?: BeforeGetListFunction; // 返回true/false，true则执行获取列表
    maxHeight?: string | number;
    style?: DomStyle;
    tableParentDomStyle?: DomStyle;
    api: {
        url: string | StringFunction; // 对应request函数的url字段
        method?: 'post' | 'get'; // 对应request函数的method字段
        query?: AnyObj | Function; // 对应request函数的query字段
        data?: AnyObj | Function; // 对应request函数的data字段
        contentTypeIsForm?: boolean; // 对应request函数的contentTypeIsForm字段
        autoPageConfig?: boolean; // 按照接口常返回的数据结构，设置分页配置
        /**
         * 分页结构
         * {
                limit: 20,
                sizes: [10, 20, 30, 40, 50],
                current: 1,
                total: 0,
            }
         */
        pageConfig?: Function; // 接口分页配置设置函数 fn(pageConfig)
        dataTransfer?: Function; // 数据转换函数，首个参数为当前请求接口的数据
    }
}

export interface PageTableConfigType extends TableConfigType {
    pageConfig?: {
        sizes?: number[];
    }
};

// 分页接口一般返回的数据结构
export type ApiPageData = {
    records: AnyObj[];
    total: number;
    size: number;
    current: number;
    pages: number;
}

// 平台接口返回数据类型
export interface PersonalSettingType {
    id: number;
    realName: string;
    mobile: string;
    roleNames: string;
    userImage: string;
}

// 表单查看数据列表类型
export interface ViewFormType {
    formItemList: ViewFormItemType[];
}

export interface ViewFormItemType {
    name: string;
    value: Array<string | number> | string | number;
    type?: 'image' | 'text';
}

// 渠道列表
export interface ChannelItemType {
    id: number;
    categoryName: string;
    child?: any;
}

// 子账号列表
export interface AccounntListItemType {
    id: number;
    account: string;
    shopId: number;
    shopName?: string;
    userId?: number;
    userName?: string;
}

// 平台列表
export interface PlatformItemType {
    id: number;
    name: string;
    code: string;
    platformCode: string;
    platformName: string;
}

// 组织树
export interface OrgTreeType {
    id: string;
    name: string;
    parentId: string;
    type: string;
    data?: any;
    checked: boolean;
    children: OrgTreeType[];
    title: string;
    label: string;
    value: string;
    disabled: boolean;
}

// 工单组件模版类型
export type WorkOrderComplateType = 'input' | 'number' | 'date' | 'select' | 'upload' | 'radioCarid' | 'area' | 'textInput' | 'multiCarid' | 'department' 
    | 'amountNumber' | 'textSelect' | 'numberValue' | 'dateofCarid' | 'ltdContact' | 'cardNumber' | 'addressCarid' | 'dateSection' | 'telephone' 
    | 'workOrderQuestion' | 'text';

// 已选择的工单组件
export interface DetailTemplateType {
    id: number;
    worksheetId: number;
    compId: number;
    compType: WorkOrderComplateType;
    compCname: string;
    compCtitle: string;
    compRequired: number;
    compRepeat: number;
    compData: string;
    compValue: string;
    compSort: number;
    createTime: string;
    createBy: number;
    compDesc?: string;
    updateTime?: any;
    updateBy?: any;
    tableColumnWidth?: number | string;
    compValueLimit?: number;
    ocrName: string;
}

export interface WorkDetailTemplateType extends DetailTemplateType {
    customId: string;
    list: any[];
}

// 工单基础组件名称
export type WorkOrderBasicComponentType = 'textInput' | 'area' | 'upload' | 'addressCarid' | 'cardNumber' | 'ltdContact' | 'telephone' | 'numberValue' | 'department' | 'amountNumber' | 'dateofCarid' | 'dateSection' | 'date';

// 角色权限数结构
export interface RolePermissionTree {
    id: string;
    name: string;
    parentId: string;
    type: string;
    data?: any;
    checked: boolean;
    children?: RolePermissionTree[];
    title: string;
    label: string;
    value: string;
}

export type BooleanCount = 1 | 0;

export interface ShopIndicatorApiIndicator {
    id: number;
    categoryId: number;
    indicatorName: string;
    indicatorCode: string;
    indicatorDesc: string;
    indicatorType: number;
    indicatorDataType: number;
    indicatorUnit: number;
    indicatorRules: number;
    indicatorStatus: number;
    createTime: string;
    createBy: number;
    updateTime: string;
    updateBy: number;
    parentId: number;
    indicatorDisplayStatus: number;
}

export interface ShopIndicatorApiShopGroup {
    blocId: number;
    platformId: number;
    platformName: string;
    shopId: number;
    shopName: string;
    indicatorImportDate: string;
    createTime: string;
    updateTime?: any;
    details: ShopIndicatorApiShopGroupDetails[];
}

export interface ShopIndicatorApiShopGroupDetails {
    id: number;
    blocId: number;
    platformId: number;
    platformName: string;
    shopId: number;
    shopName: string;
    indicatorId: number;
    indicatorCategoryId?: any;
    indicatorName: string;
    indicatorCode: string;
    indicatorValue: string;
    indicatorImportDate: string;
    createTime: string;
    updateTime?: any;
    compareIndicatorValue?: string;
    compareIndicatorDate?: string;
}

export interface ShopIndicatorPageIndicatorItem extends ShopIndicatorApiShopGroupDetails {
    children: ShopIndicatorPageIndicatorItem[];
}

export type FixedLengthArray<T, N extends number> = [T, ...T[]] & { length: N };

// 店铺指标页面，数据列表
export type ShopIndicatorShopList = {
    blocId: number;
    platformId: number;
    platformName: string;
    shopId: number;
    shopName: string;
    indicatorImportDate: string;
    createTime: string;
    updateTime?: any;
    detail: ShopIndicatorPageIndicatorItem[];
    details: ShopIndicatorApiShopGroupDetails[];
}

// 常用树结构
export interface TreeType {
    id: string;
    name: string;
    parentId: string;
    type: string;
    data?: any;
    checked: boolean;
    children: TreeType[];
    title: string;
    label: string;
    value: string;
    disabled: boolean;
}

// 渠道表所有数据类型
export interface ChannelEntity {
    id: number;
    categoryName: string;
    categoryCode: string;
    platformId: number;
    platformName: string;
    createBy: number;
    createTime: string;
}

// 指标基准实体
export interface IndicatorStandardEntity {
    id: number;
    blocId: number;
    shopId: number;
    shopName: string;
    platformId: number;
    platformName: string;
    indicatorId: number;
    indicatorCategoryId: number;
    indicatorType: number;
    indicatorName: string;
    indicatorDataType: number;
    standardValue: string;
    standardQualifyRule: number;
    createTime: string;
    createBy: number;
    updateTime: string;
    updateBy: number;
}

export interface ChartRecordList {
    id: number;
    blocId: number;
    platformId: number;
    platformName: string;
    shopId: number;
    shopName: string;
    accountId: number;
    accountName: string;
    accountUserId: number;
    accountUserName: string;
    chatDataId: number;
    chatDataDate: string;
    chatUid: string;
    chatNickname: string;
    chatContent?: any;
    chatRoundNum: number;
    chatTime: string;
    recordProcessStatus: number;
    recordProcessDesc: string;
    recordProcessResultStatus: number;
    recordProcessLabelIds: string;
    assignmentRecordId: number;
    assignmentCheckUserid: number;
    assignmentCheckStatus: 0 | 1 | 2; // （0未审核，1已审核，2审核有问题）
    assignmentCheckDeduct?: any;
    assignmentCheckTime?: any;
    machineIndex: number;
    threadIndex: number;
    version: number;
    createTime: string;
    updateTime: string;
}

export interface ChartRecordDetail {
    id: number;
    blocId: number;
    chatRecordId: number;
    content: string;
    contentLength: number;
    contentTime: string;
    contentSort: number;
    personnelType: 1 | 2; // 1买家，2客服
    personnelName: string;
    labels: string;
    labelIds: string;
    emotionProcessResult: number;
    emotionProcessDesc: string;
    createTime: string;
}

export interface EvaluateLabel {
    id: number;
    parentId: number;
    parentPath: string;
    blocId: number;
    shopIds: string;
    labelType: number;
    labelName: string;
    labelLayer: number;
    labelDispose: string;
    isOpen: number;
    isEnable: 0 | 1;
    disableBlocIds: string;
    createTime: string;
    updateTime: string;
    labelId: number;
}

export interface EvaluateLabelTree extends EvaluateLabel {
    children: EvaluateLabelTree[];
}

export interface ShopEntity {
    id: number;
    blocId: number;
    platformId: number;
    platformName: string;
    shopCategoryId: number;
    shopName: string;
    shopMainAccount: string;
    shopStatus: number;
    shopUrl: string;
    shopDesc: string;
    shopLevel: number;
    createTime: string;
    createBy: number;
    updateTime: string;
    updateBy: number;
    strShopStatus?: any;
    strShopLevel?: any;
    categoryName?: any;
}

export interface ProgramTree {
    id: string;
    isBloc: number;
    name: string;
    title: string;
    pid?: string;
    appId?: any;
    data?: any;
    checked: boolean;
    children: ProgramTree[];
}

export interface LMSVedio {
    id: number;
    blocId?: number;
    categoryId?: number;
    ossVideoid?: number;
    ossAuditJobid?: any;
    ossAuditStatus?: any;
    ossAuditCode?: any;
    videoOriginalName: string;
    videoSize?: any;
    videoDuration: number;
    createBy?: number;
    createName: string;
    createTime: string;
    updateTime?: any;
    videoCover?: string;
}

export interface LMSTopic {
    id: number;
    blocId?: number;
    categoryId?: number;
    topicName: string;
    topicType: 0 | 1 | 2 | 3; // 0判断，1单选，2多选，3简答题
    topicStatus: number;
    topicImagePath?: string;
    topicAnalysis?: string;
    topicSort?: any;
    createBy?: any;
    createName: string;
    createTime: string;
    updateTime?: any;
    optionVos: {
        isCorrect: 0 | 1;
        optionContent: string;
        optionId: number;
    }[];
}

export interface LMSDocument {
    id: number;
    blocId?: any;
    categoryId?: any;
    docOriginalName: string;
    docPath?: any;
    createBy?: any;
    createName: string;
    createTime: string;
    updateTime?: any;
}

// 认证计划列表数据
export interface CertificationList {
    id: number;
    name: string;
    type: 1 | 2; // 1文件夹,2认证/认证计划
    child: CertificationList[];
    createTime?: string;
};

export type UserCertificationStatus = 0 | 1 | 3 | 4;

export interface ExamTopicItem {
    id: number;
    isUpdateCategoryId: any;
    categoryId: any;
    topicName: string;
    topicType: 0 | 1 | 2 | 3; // 试题类型（0判断，1单选，2多选，3简答题）
    topicStatus: any;
    isUpdateStatus: any;
    topicScore: number;
    topicImagePath: string;
    topicAnalysis: any;
    optionVos: ExamTopicOptionVos[]; 
}

interface ExamTopicOptionVos {
    optionId: number;
    optionContent: string;
    isCorrect: 0 | 1; 
}

// 1 summary填空, 2 choice选择题, 3 problems计算题，4 calculation应用题，5 trueOrFalse判断题
export type TopicType = 'summary' | 'choice' | 'problems' | 'calculation' | 'trueOrFalse';

export type TopicHtmlType = 'summary' | 'choo' | 'trueOrFalse';

export type TopicTypeNumber = 1 | 2 | 3 | 4 | 5;

// =========试题保存修改=========
export interface TopicSaveApi {
    id: number;
    type: TopicTypeNumber;
    answers: TopicSaveAnswer[];
    categoryId: number;
    categoryName: string;
    content: string;
    difficulty: number;
    imgs: string[];
    video: string;
    choiceDtos: ChoiceDtos[];
    sameFlg: string;
    score: number;
}

export interface TopicSaveAnswer {
    content: string;
}

export interface ChoiceDtos {
    item: string;
    itemContent: string;
}
// =========试题保存修改结束=========

// ========试题预览=============
export interface QuestionItem {
    id: number;
    categoryName: string;
    categoryId: number;
    content: string;
    sort: any;
    choiceDtos?: ChoiceDtos[];
    video: string;
    videoQrCode: string;
    answers: string[] | null;
    imgs: string[] | null;
    difficulty: number;
    questionsType: TopicTypeNumber; 
}
// ========试题预览结束=============

export interface GeneratePaperSmallQuestion {
    categoryId: string;
    difficulty: number;
    num: number;
    score: number;
};